#pragma once

#include <cstdint>
#include <string>
#include <vector>
#include <memory>
#include <map>

/**
 * 通用MUD游戏协议规范 v1.0
 * 
 * 本协议设计为与客户端实现语言和框架无关的通用接口标准
 * 支持JavaScript、Java、C++、Unity3D、虚幻引擎、Godot等多种客户端
 * 
 * 协议特点：
 * - 基于JSON格式，易于解析和调试
 * - 支持UDP和WebSocket传输
 * - 向下兼容现有Qt客户端
 * - 扩展性强，易于添加新功能
 */

namespace UniversalProtocol 
{
    // 通用数据类型定义
    using PlayerId = uint32_t;
    using Timestamp = uint64_t;
    using MessageId = uint16_t;
    
    // 消息类型枚举（与现有PacketType保持兼容）
    enum class MessageType : uint16_t 
    {
        // 连接管理
        PLAYER_JOIN = 10,           // 玩家加入请求/响应
        PLAYER_LEAVE = 11,          // 玩家离开通知
        HEARTBEAT = 12,             // 心跳包（新增）
        
        // 游戏流程
        GAME_START = 100,           // 开始游戏请求
        GAME_STATUS = 101,          // 游戏状态同步
        ATTACK = 102,               // 攻击指令
        LEVEL_UP = 103,             // 升级通知
        COMBAT_MESSAGE = 104,       // 战斗消息
        
        // 扩展消息类型（为未来功能预留）
        CHAT_MESSAGE = 200,         // 聊天消息
        SYSTEM_NOTIFICATION = 201,  // 系统通知
        ERROR_RESPONSE = 500,       // 错误响应
        
        // 协议协商（新增）
        PROTOCOL_HANDSHAKE = 1000,  // 协议握手
        CLIENT_INFO = 1001          // 客户端信息
    };
    
    // 游戏状态枚举
    enum class GameState : uint8_t 
    {
        WAITING = 0,        // 等待中
        IN_COMBAT = 1,      // 战斗中
        LEVEL_COMPLETE = 2, // 关卡完成
        GAME_OVER = 3       // 游戏结束
    };
    
    // 客户端类型识别
    enum class ClientType : uint8_t 
    {
        UNKNOWN = 0,
        QT_NATIVE = 1,      // 原生Qt客户端
        JAVASCRIPT = 2,     // JavaScript/Web客户端
        JAVA = 3,           // Java客户端
        UNITY3D = 4,        // Unity3D引擎
        UNREAL_ENGINE = 5,  // 虚幻引擎
        GODOT = 6,          // Godot引擎
        CUSTOM = 99         // 自定义客户端
    };
    
    // 协议版本信息
    struct ProtocolVersion 
    {
        uint16_t major = 1;
        uint16_t minor = 0;
        uint16_t patch = 0;
        
        std::string toString() const 
        {
            return std::to_string(major) + "." + std::to_string(minor) + "." + std::to_string(patch);
        }
    };
    
    // 通用消息基类
    struct UniversalMessage 
    {
        MessageType type;
        PlayerId playerId;
        Timestamp timestamp;
        MessageId messageId;        // 消息唯一标识（用于应答匹配）
        
        UniversalMessage(MessageType msgType, PlayerId pId = 0) 
            : type(msgType), playerId(pId), timestamp(0), messageId(0) 
        {
        }
        
        virtual ~UniversalMessage() = default;
        
        // 纯虚函数，子类必须实现
        virtual std::string toJson() const = 0;
        virtual bool fromJson(const std::string& jsonStr) = 0;
    };
    
    // 玩家属性数据（通用格式）
    struct PlayerAttributes 
    {
        uint32_t level = 1;
        uint32_t health = 80;
        uint32_t maxHealth = 80;
        uint32_t attackPower = 15;
        uint32_t defense = 5;
        uint32_t critChance = 10;           // 百分比
        double critMultiplier = 2.0;
        uint32_t hitChance = 85;            // 百分比
        uint32_t dodgeChance = 8;           // 百分比
        uint32_t totalKills = 0;
        GameState gameState = GameState::WAITING;
        bool isInAutoCombat = false;
        
        std::string toJson() const;
        bool fromJson(const std::string& jsonStr);
    };
    
    // 怪物属性数据（通用格式）
    struct MonsterAttributes 
    {
        uint32_t level = 1;
        uint32_t health = 0;
        uint32_t maxHealth = 0;
        uint32_t attackPower = 0;
        uint32_t defense = 0;
        uint32_t critChance = 0;
        double critMultiplier = 1.0;
        uint32_t hitChance = 80;
        uint32_t dodgeChance = 0;
        std::string name;
        
        std::string toJson() const;
        bool fromJson(const std::string& jsonStr);
    };
    
    // 客户端信息
    struct ClientInfo 
    {
        ClientType clientType = ClientType::UNKNOWN;
        std::string clientName;             // 客户端名称，如 "Unity3D Client"
        std::string clientVersion;          // 客户端版本
        ProtocolVersion protocolVersion;    // 支持的协议版本
        std::vector<std::string> supportedFeatures; // 支持的功能列表
        
        std::string toJson() const;
        bool fromJson(const std::string& jsonStr);
    };
    
    // 具体消息类型定义
    
    // 协议握手消息
    struct HandshakeMessage : public UniversalMessage 
    {
        ClientInfo clientInfo;
        
        HandshakeMessage() : UniversalMessage(MessageType::PROTOCOL_HANDSHAKE) {}
        
        std::string toJson() const override;
        bool fromJson(const std::string& jsonStr) override;
    };
    
    // 玩家加入消息
    struct PlayerJoinMessage : public UniversalMessage 
    {
        std::string playerName;     // 可选，客户端可指定玩家名
        
        PlayerJoinMessage() : UniversalMessage(MessageType::PLAYER_JOIN) {}
        
        std::string toJson() const override;
        bool fromJson(const std::string& jsonStr) override;
    };
    
    // 游戏状态消息
    struct GameStatusMessage : public UniversalMessage 
    {
        PlayerAttributes playerData;
        MonsterAttributes monsterData;
        std::string message;                // 状态描述信息
        
        GameStatusMessage() : UniversalMessage(MessageType::GAME_STATUS) {}
        
        std::string toJson() const override;
        bool fromJson(const std::string& jsonStr) override;
    };
    
    // 战斗消息
    struct CombatMessage : public UniversalMessage 
    {
        std::string message;                // 战斗描述文本
        
        CombatMessage() : UniversalMessage(MessageType::COMBAT_MESSAGE) {}
        
        std::string toJson() const override;
        bool fromJson(const std::string& jsonStr) override;
    };
    
    // 升级消息
    struct LevelUpMessage : public UniversalMessage 
    {
        PlayerAttributes newPlayerData;
        std::string message;                // 升级描述信息
        
        LevelUpMessage() : UniversalMessage(MessageType::LEVEL_UP) {}
        
        std::string toJson() const override;
        bool fromJson(const std::string& jsonStr) override;
    };
    
    // 攻击消息
    struct AttackMessage : public UniversalMessage 
    {
        uint32_t damage = 0;                // 造成的伤害
        uint32_t targetHealth = 0;          // 目标剩余血量
        std::string message;                // 攻击描述
        
        AttackMessage() : UniversalMessage(MessageType::ATTACK) {}
        
        std::string toJson() const override;
        bool fromJson(const std::string& jsonStr) override;
    };
    
    // 错误响应消息
    struct ErrorMessage : public UniversalMessage 
    {
        uint32_t errorCode;
        std::string errorDescription;
        MessageId originalMessageId;        // 引发错误的原始消息ID
        
        ErrorMessage() : UniversalMessage(MessageType::ERROR_RESPONSE), errorCode(0), originalMessageId(0) {}
        
        std::string toJson() const override;
        bool fromJson(const std::string& jsonStr) override;
    };
    
    // 消息工厂类
    class MessageFactory 
    {
    public:
        static std::unique_ptr<UniversalMessage> createFromJson(const std::string& jsonStr);
        static std::unique_ptr<UniversalMessage> createFromType(MessageType type);
        
        // 协议版本兼容性检查
        static bool isProtocolCompatible(const ProtocolVersion& clientVersion, const ProtocolVersion& serverVersion);
    };
    
    // 协议适配器接口
    class IProtocolAdapter 
    {
    public:
        virtual ~IProtocolAdapter() = default;
        
        // 将通用消息转换为特定客户端格式
        virtual std::vector<uint8_t> serializeMessage(const UniversalMessage& message) = 0;
        
        // 从特定客户端格式解析为通用消息
        virtual std::unique_ptr<UniversalMessage> deserializeMessage(const std::vector<uint8_t>& data) = 0;
        
        // 获取适配器支持的客户端类型
        virtual ClientType getSupportedClientType() const = 0;
        
        // 检查消息格式是否匹配此适配器
        virtual bool canHandle(const std::vector<uint8_t>& data) const = 0;
    };
    
} // namespace UniversalProtocol 